Method and system for platform-independent application development

ABSTRACT

A non-transitory computer-readable medium having instructions that when executed cause the implementation of a method is disclosed herein. The medium has instructions for facilitating the execution of at least a first hybrid application on a first device, the first hybrid application including commands related to platform-specific functionality and platform-independent functionality of the first device. The method includes initializing a loosely-coupled native engine configured to receive commands from the first hybrid application and to facilitate platform-specific functionality on the first device. The loosely-coupled native engine includes a webserver module. The method includes receiving commands from the first hybrid application, wherein at least one of the commands includes a device command to be converted to a corresponding platform-specific code prior to execution of the platform-specific code. And the method includes creating a handler to serve the device command and facilitate execution of the corresponding platform-specific code.

RELATED APPLICATION

The present application is a continuation of and claims priority to U.S.patent application Ser. No. 13/874,305, filed on Apr. 30, 2013 andentitled “Method and System for Platform-Independent ApplicationDevelopment,” the contents of which are hereby incorporated by referencein their entirety.

BACKGROUND

The present application relates generally to the field of computer, thinclient, and mobile device applications and more specifically to hybridapplications that support functionality that may be accessed via acombination of web programming and platform-specific executable code.

Since 2007, the mobile application industry has grown significantly. Forinstance, recent research suggests that while in 2007 the market formobile applications was nonexistent, in 2013 the two primary mobileapplication stores or marketplaces combined include more than a millionapplications. And it is expected that by 2016 the mobile applicationindustry will reach almost $50 B in revenue.

Developers seeking entry into the industry usually have the options ofeither programming independent versions of their products for eachplatform, programming their products entirely in a web programminglanguage, such as hypertext markup language 5 (HTML5) and/or JavaScript,or using a hybrid solution that includes aspects of bothplatform-specific programming and web programming. These hybridsolutions usually rely on access through a mobile device's web browserthat may expose the device to security risks, among other things.Additionally, hybrid solutions may restrict or limit access tospecialized hardware, such as a global positioning system (GPS), camera,and other peripherals, among other things. Further, hybrid solutionstypically require a constant connection to the Internet or may requirecertain tightly-coupled components or resources that may limit their useon a thin client.

SUMMARY

There is a need for a method and system for hybrid applications thatwill facilitate the development of platform-independent applications. Itwould be preferable that implementing a hybrid application would notexpose the mobile device to potential security risks. There is a needfor a method and system for developing a hybrid application that may beimplemented on mobile devices and thin clients.

A method of executing a hybrid application on a device is disclosedherein. The hybrid application includes commands related to bothplatform-specific functionality and platform-independent functionalityof the device. The method includes steps of initializing aloosely-coupled native engine configured to receive commands from thehybrid application. The loosely-coupled native engine is furtherconfigured to facilitate implementation of platform-specificfunctionality on the device. And the loosely-coupled native engineincludes a Hypertext Transfer Protocol (HTTP) server and initializingthe loosely-coupled native engine comprises initializing the HTTPserver. The method includes assigning a unique instance ID to the HTTPserver, and configuring the HTTP server to only accept commandscomprising the unique instance identifier (ID). The method includesinitializing the hybrid application. The method includes receivingcommands from the hybrid application. The commands include the uniqueinstance ID of the HTTP server, and at least one of the commandscomprises a device command to be converted to a correspondingplatform-specific executable code prior to execution of theplatform-specific executable code. The method includes verifying thatthe commands comprise the unique instance ID of the HTTP server. And themethod includes creating a handler to serve the device command andfacilitate execution of the corresponding platform-specific executablecode.

Also disclosed herein is a device compatible with a first platform. Thedevice comprises a memory configured to store local files, aloosely-coupled native engine, and a hybrid application. Theloosely-coupled native engine comprises a webserver module, a commanddispatch system connected to the webserver module and configured to passcommands to, and receive commands from, the webserver module, and aplurality of handlers configured to handle commands from the commanddispatch system and serve a resulting code. The webserver module of thenative engine receives a unique instance ID upon initialization of aninstance of the webserver module, and the unique instance ID istransmitted to the memory. The webserver module is configured to rejectcommunications that do not include the unique instance ID. The hybridapplication is programmed in a platform-independent developmentenvironment, wherein the hybrid application comprises commands to betransmitted to the webserver module of the loosely-coupled nativeengine, and wherein the commands comprise the unique instance ID of thewebserver module.

A non-transitory computer-readable medium having instructions that whenexecuted cause the implementation of a method is disclosed herein. Themedium has instructions for facilitating the execution of at least afirst hybrid application on a first device, the first hybrid applicationcomprising commands related to platform-specific functionality andplatform-independent functionality of the first device. The methodincludes initializing a loosely-coupled native engine configured toreceive commands from the first hybrid application and to facilitateplatform-specific functionality on the first device. The loosely-couplednative engine comprises a webserver module. The method includesreceiving commands from the first hybrid application, wherein at leastone of the commands comprises a device command to be converted to acorresponding platform-specific code prior to execution of theplatform-specific code. And the method includes creating a handler toserve the device command and facilitate execution of the correspondingplatform-specific code.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates an embodiment of a platform-independent applicationdevelopment system.

FIG. 2 illustrates an application distribution framework.

FIG. 3 illustrates a client device according to the present disclosure.

FIG. 4 illustrates another embodiment of a client device.

FIG. 5 illustrates a native engine in a platform-independent applicationdevelopment system.

FIG. 6 illustrates a remote server according to the present disclosure.

FIG. 7 illustrates a method of processing an application according tothe present disclosure.

FIG. 8 illustrates another embodiment for processing an application.

Like reference numbers and designations in the various drawings indicatelike elements.

DETAILED DESCRIPTION

In the following detailed description, reference is made to theaccompanying drawings that form a part hereof, and in which is shown byway of illustration specific embodiments in which the disclosure may bepracticed. These embodiments are described in sufficient detail toenable those skilled in the art to practice the disclosure, and it is tobe understood that other embodiments may be utilized and that variouschanges may be made without departing from the spirit and scope of thepresent disclosure. The following detailed description is, therefore,not to be taken in a limiting sense.

FIG. 1 shows one embodiment of a system 100 for platform-independentapplication development comprising client 105, clients 110 a-d, remoteserver 120, and database 125 all connected via Internet 115. As usedherein, platform-independent application development refers to thedevelopment of applications in one programming language, referred to asa platform-independent development language, or on one platform, thatmay be implemented on a plurality of platforms without programming, orotherwise developing, a new version of the application for eachplatform. A platform may be any type of computer or other electronichardware device having a standard design for use with a compatibleoperating system. Additionally, as used herein, a platform may be anoperating system, such as Windows-based OS, Mac-based OS, UNIX, Linux,iOS, Android, Windows Phone-based OS, Blackberry-based OS, etc. Thus,for example, an application may be programmed in a first language, forinstance, a platform-independent development language, and may then beimplemented on both iOS and Android platforms without having to programnative iOS or Android versions of the application.

As seen in FIG. 1, clients 105 and 110 a-110 d may all be connected toInternet 115. Client 105 may comprise any suitable client deviceconfigured to access or otherwise load a system 100 forplatform-independent application development. For instance, client 105may comprise a Windows-based machine accessing the system 100 forplatform-independent application development via a web browsercomprising a user interface (UI). Alternatively, client 105 may comprisea system 100 for platform-independent application development loaded inits own internal memory so as to facilitate application developmentwithout a connection to Internet 115.

Client 110 a represents a tablet or smartphone configured to accessInternet 115 via a wired or wireless connection. For instance, client110 a may comprise a tablet with a radio connection to a local router,such as via WiFi, or to a remote cellular tower via long-term evolution(LTE), among other things. Of course, any suitable connection iscontemplated by the present disclosure, including different cellularwireless connections, such as global system for mobile (GSM), generalpacket radio service (GPRS), code division multiple access (CDMA),evolution-date optimized (EV-DO), universal mobile telecommunicationssystem (UMTS), enhanced data rates for GSM evolution (EDGE), worldwideinteroperability for microwave access (WiMAX), LTE, and/or any othernext generation transmission standard. In another embodiment, client 110a may connect to Internet 115 via a wired connection such as an Ethernetconnection to a router, and a cable or DSL connection to an ISP. Clients110 b and 110 c also represent mobile devices, such as tablets,smartphones, or any other relevant device, configured to connect toInternet 115 via either a wired or wireless connection.

Client 110 d represents a dumb terminal or thin client device(collectively “thin client”). As used herein, a thin client representsany device designed to be lightweight and thus reliant or dependent onanother device or computer for a bulk of the processing power necessaryto perform its operations. For example, in a warehouse setting, aplurality of hand-held devices may be utilized to scan merchandise andthen transmit processing related to the scanned merchandise back to acentral computer or computers. The scanned information may be enteredinto a database for tracking stock of a given product, for instance. Inanother example, a plurality of thin clients may be set up at a store ormovie theater to permit self-checkout, and the plurality of thin clientsmay be networked with a central server or servers to handle part or amajority of the data processing.

Remote server 120 represents any suitable form of device configured toexchange data with clients 105 and 110 a-110 d. Remote server 120 maycomprise a webserver configured to host data associated with a websiteor otherwise interact with clients 105 and 110 a-110 d. For instance, inone example, remote server 120 may comprise an Apache server configuredto function using HTTP protocol. Of course, any other suitable form ofremote server 120 is contemplated by the present disclosure. Database125 may comprise any suitable form of database, such as a relationalmodel, an object model, or an object relational model database, amongother things. For instance, database 125 may comprise a relationalstructured query language (SQL) database on remote server 120. Inanother example, database 125 may be remote to remote server 120. In yetanother example, database 125 may comprise a Sybase® database on remoteserver 120.

A user may access the platform-independent development environment viaclient 105. The user may be presented with a graphical user interfacevia which the user may program a hybrid application to work on aplurality of platforms. As used herein, a hybrid application is anapplication developed in a system 100 for platform-independentapplication development, and combining elements of both a nativeapplication and a Web application. Thus, the hybrid application maycomprise commands related to functionality that may be accessedindependent of the native functionality of a platform or without use ofplatform-specific executable code.

For example, the hybrid application may include functionality related todisplaying a UI on a mobile device and allowing a user to interact withthe UI. The hybrid application may also comprise elements to be accessedthrough the native functionality of a platform. As used herein,functionality that can only be accessed through the native framework ofa platform is referred to as platform-specific functionality. Forinstance, the hybrid application may include functionality related to aGPS of the mobile device, and in some cases, functionality related tothe GPS of a mobile device may be platform-specific functionality. Inone embodiment, platform-specific functionality may be achieved usingplatform-specific executable code, which may correspond to aplatform-specific command. Said otherwise, a platform-specific command,or device command, may be drawn to platform-specific functionality of agiven platform.

The user may upload the hybrid application to a remote server 120, andthe hybrid application may be accessed and/or downloaded to a clientdevice 110 a-110 d. For instance, client 110 a of a first platform,client 110 b of a second platform, client 110 c of a third platform, andthin client 110 d of a fourth platform may all access the same hybridapplication, and the hybrid application may be configured to operate onthe first through fourth platforms without having to codeplatform-specific versions of the hybrid application in order to accessplatform-specific functionality.

FIG. 2 illustrates a method and system by which a hybrid application 201may be distributed to clients 210 a-210 c according to one embodiment ofthe present disclosure. A hybrid application 201 may be pushed to anapplication distribution center 202 from which the hybrid application201 may be distributed to clients 210 a-210 c.

In the context of the system 100 for platform-independent applicationdevelopment, the application distribution center 202 may be housed onremote server 120. After a developer completes development of a hybridapplication 201, the developer may then cause the hybrid application 201to be uploaded to the application distribution center 202. Thereafter, auser of client 210 a may elect to download and/or install hybridapplication 201. A user interface of client 210 a may direct the user toa website to download hybrid application 201, or hybrid application 201may be automatically pushed to client 210 a. In another example, hybridapplication 201 may be stored in a database, such as database 125 shownin FIG. 1, and may be accessed and otherwise downloaded by way of a userinterface of client 210 a. Any other suitable mode or means ofapplication distribution is contemplated by the present disclosure.

FIG. 3 shows a client 310 in one embodiment comprising a hybridapplication 301, a web browser 303, local files 304, and a native engine306. As shown in FIG. 3, client 310 may be connected to the Internet315. A remote server 320 may also be connected to the Internet 315. Alsoas illustrated in FIG. 3, Native engine 306 may comprise a webservermodule 330 configured to receive commands related toplatform-independent functionality. Native engine 306 may also comprisea handler module 345 configured to receive commands related toplatform-specific functionality. Native engine 306 may have logicalconnections, existing in hardware and/or software, to web browser 303,hybrid application 301, and/or local files 304. Likewise, web browser303 may have logical connections, existing in hardware and/or software,to hybrid application 301, to native engine 306, and optionally to localfiles 304. Hybrid application 301 may have logical connections to localfiles 304, native engine 306, and web browser 303. Finally, local files304 may have logical connections to hybrid application 301, nativeengine 306, and optionally to web browser 303.

Hybrid application 301 may comprise any application programmed to takeadvantage of functionality based on web programming languages, such ashypertext markup language (HTML), HTML5, cascade style sheets (CSS), andJavaScript (or asynchronous javascript and xml (AJAX), which is usedinterchangeably in the present disclosure), among other things, butnevertheless offers access to platform-specific functionality through athin native container referred to as native engine 306 in the presentdisclosure. For instance, hybrid application 301 may be developedprimarily using HTML5 and JavaScript, but also relying on native engine306 to interpret commands from hybrid application 301 into code that maybe executed by a given platform. Native engine 306 may comprise anycombination of software and hardware configured to receive commandsrelated to platform-specific functionality and/or platform-independentfunctionality, and assist in facilitating the execution and/orimplementation thereof. For instance, native engine 306 may beconfigured to receive commands from hybrid application 301.

In one example, hybrid application 301 may include commands related toplatform-specific functionality such as the camera on an iOS device,among other things. As used herein, a command may comprise a line ofcode in an application or program directing the implementation orperformance of a task or functionality on a client 310. In oneembodiment, a command may direct a program, such as a virtual machine ora web browser, among other things, to assist to facilitate theimplementation or performance of a task or functionality on a client310. For instance, hybrid application 310 may comprise commands relatedto displaying images and content and exchanging information betweenclient 310 and a remote server 120. In this example, web browser 303 andwebserver module 330 may work together to facilitate the display of therelevant images and content, among other platform-independentfunctionality.

As used herein, facilitating the implementation or execution of acommand, executable code, or a given functionality refers to theparticipation of a given component or program in a particular task. Forinstance, in one example, native engine 306 may participate in theimplementation of a command from a hybrid application 301 by receivingthe command, and transmitting the command to the appropriate module,such as webserver module 330 or a handler module 345. Native engine 306may receive executable code from the webserver module 330 and/or thehandler module 345 and may transmit or otherwise pass the receivedexecutable code to the appropriate module or component of client 310 sothat the received executable code may be executed or implemented byclient 310. In one example, native engine 306 may receive executablecode from webserver module 330, which it may transmit to web browser303. In another example, native engine 306 may receive executable codefrom handler module 345, which it may transmit to a relevant module ofclient 310 for execution. Alternatively, webserver module 330 and/orhandler module 345 may be configured to transmit executable codedirectly to a relevant module of client 310.

Hybrid application 301 may rely on web browser 303 to interpret andexecute commands of hybrid application 301 that have been programmed in,for instance, HTML5 and JavaScript. For instance, portions of hybridapplication 301 may be programmed in a combination of HTML5 andJavaScript in order to take advantage of graphical display andinteraction functionality accessible through, and built into, webbrowser 303. In one example, hybrid application 301 may comprisecommands related to a graphical user interface comprising form elementssuch as drop down menus, buttons, and text boxes, among other things. Inone embodiment, the graphical user interface of hybrid application 301may not need to access platform-specific functionality in order to bedisplayed. In another example, hybrid application 301 may comprisecommands related to logging into, accessing, writing and reading from adatabase 125. In this example, hybrid application 301 may not need toaccess platform-specific functionality in order to process the commandsrelated to database 125, and may perform the commands through webbrowser 303.

Web browser 303 may comprise a standard web browser of a platform, suchas, for example, a WebKit-based browser such as Safari browser on an iOSdevice, a Chrome browser on an Android device, a Gecko-based browsersuch as Firefox, or a Presto-based browser such as Opera, among otherbrowsers. Alternatively, web browser 303 may comprise a non-standard webbrowser, such as a web browser integrated into native engine 306. In oneexample, web browser 303 may comprise a thin browser integrated intonative engine 306.

Local files 304 represent any number and configuration of local filesthat may be relied upon or accessed by hybrid application 301, webbrowser 303, and/or native engine 306. Local files 304 may be stored ona memory of client 310, and the memory may be integrated or removable,among other things. In one example, the memory may be a non-transitorycomputer-readable medium comprising instructions for executing a method.

For instance, local files 304 may store information related to the userand/or the client 310. Local files 304 may store a cache of local data.Local files 304 may be configured to facilitate the functionality ofhybrid application 301 and native engine 306. For instance, local files304 may contain application files that may reside locally in order toaccelerate execution of hybrid application 301, native engine 306,and/or web browser 303 code. Local files 304 may also permit client 310to function and to execute hybrid application 301 without a connectionto Internet 315. In one embodiment, local files 304 may comprise localfiles that may be updated each time a hybrid application 301 or nativeengine 306 synchronizes with a remote server, such as remote server 120in FIG. 1. For instance, local files 304 may comprise, among otherthings, image resources for a hybrid application 301, and the imageresources in local files 304 may be updated any number of times, asrequired, in order to keep hybrid application 301 running the mostup-to-date version possible. Of course, as would be readily apparent toone of ordinary skill in the art, the present disclosure contemplatesuses of local files 304 beyond the preceding illustrative list.

Native engine 306 represents a container or native engine configured toreceive commands from hybrid application 301 and to translate thosecommands into executable native code, as necessary. Native engine 306may be further configured to otherwise handle and/or facilitate theexecution of commands using web browser 303. For instance, native engine306 may be configured to facilitate the implementation ofapplication-specific and application-independent functionality viawebserver module 330 and handler module 345. As used herein, nativeengine 306 is a loosely-coupled native engine 306. Generally speaking,loosely-coupled components are components that are not required to havedirect knowledge of each other to function, where coupling refers to thedegree of direct knowledge that one component may have of the others.Applying this definition to native engine 306, a loosely-coupled nativeengine 306 is a native engine that functions independently of hybridapplication 301 and/or a remote server, such as remote server 120 inFIG. 1. Specifically, loosely-coupled native engine 306 is configured tobe run on an entirely different device from hybrid application 301 andclient 310, and nevertheless still permit hybrid application 301 tofunction on client 310, as seen in FIG. 4. In one example, theintegration of webserver module 330 into native engine 306 mayfacilitate and/or otherwise permit the loosely-coupled nature of nativeengine 306.

Hybrid application 301 of client 310 may comprise commands related to acombination of functionality including platform-specific functionalityand platform-independent functionality. In one example, while theplatform-specific functionality may need to be executed relying uponcode specific to the given platform of client 310, theplatform-independent functionality may be executed using a combinationof webserver module 330 and web browser 303. As used herein,platform-independent functionality may be any functionality that may beaccessed without recourse to platform-specific code or the underlyingnative framework of a platform. As would be readily apparent to one ofordinary skill in the art, the platform-independent functionality of afirst platform may differ from the platform-independent functionality ofa second platform. Likewise, platform-specific functionality of a firstplatform may differ from the platform-specific functionality of a secondplatform.

In some cases, both platform-specific and platform-independentfunctionality may pass through native engine 306. Hybrid application 301may pass commands for platform-specific functionality to native engine306, and native engine 306 may facilitate the execution of theplatform-specific functionality. Hybrid application 301 may also passcommands related to platform-independent functionality to native engine306, in order to facilitate the execution of platform-independentfunctionality via webserver module 330. For example, hybrid application301 may comprise commands, such as user-interface-related commands, thatmay be executed using webserver module 330, web browser 303, and localfiles 304. In one embodiment, hybrid application 301 may include a userinterface that may be displayed by client 310. Additionally, hybridapplication 301 may require access to a peripheral or platform-specificfunctionality of client 310, such as a GPS unit or a camera, among otherthings. As hybrid application 301 may need access to such functionality,commands may be passed to native engine 306, the native engine mayreturn executable native code, and the resulting executable native codemay then be executed within the platform framework of client 310.

In one example, hybrid application 301 may comprise a music playerapplication and client 310 may comprise a smartphone or other handhelddevice. As used herein, initializing or initialization refers tostarting, running, or creating an instance, or instantiating a programor application, such as hybrid application 301 or native engine 306,among others. When a user initializes hybrid application 301, the usermay be presented with a user interface implemented using a combinationof webserver module 330, web browser 303, and local files 304. Forinstance, the user may be presented with a logon screen or a selectionof music from which to select a music station. In this example, aportion of the functionality may be achieved using commands programmedin HTML5 and JavaScript, transmitted to webserver module 330, andimplemented by web browser 303. However, other functionality, such asfunctionality related to the operation of LEDs on client 310, access toand use of a GPS device, camera device, and any other platform-specificfunctionality, may be handled by handler module 345 of native engine306. For instance, hybrid application 301 may request a geospatiallocation of client 310 in order to provide relevant advertising. Suchfunctionality may comprise platform-specific code and may thus need tobe translated or otherwise converted into executable native code inorder to be implemented on client 310. For instance, in one embodiment,native engine 306 and/or handler module 345 may comprise a lookup tableconfigured to facilitate the conversion of a command related toplatform-specific functionality into a platform-specific executablecode. In another example, information that could assist in theconversion may be stored in a database on client 310, or remotely in aremote server 120. The database may comprise any suitable database,including, but not limited to, a SQL or Sybase® database, among otherthings.

In another embodiment, hybrid application 301 may comprise a socialnetwork photo sharing program. In this example, hybrid application 301may require access to the camera hardware of client 310. Therefore,whenever hybrid application 301 needs access to platform-specificfunctionality, such as the camera hardware of client 310,platform-specific code corresponding to the desired functionality may bereceived from native engine 306 and/or handler module 345 and executedon client 310. Additionally, and particularly if the code is usedfrequently, it may be stored in local files 304 in order to accelerateimplementation of hybrid application 301.

FIG. 4 illustrates another embodiment of a platform-independentapplication environment. Client 410 comprises a hybrid application 401,an optional web browser 403, and local files 404. Additionally, nativeengine 406 may run remotely from client 410 and may comprise a webservermodule 430 and a handler module 445. For instance, client 410 maycomprise a thin client, and native engine 406 may run on another machineor server. Internet 415 may optionally be connected to either client 410or native engine 406, or both client 410 and native engine 406. A remoteserver 420 may also be connected to the Internet 415

In operation, much as described above in relation to FIG. 3, hybridapplication 401 may comprise a combination of platform-specific andplatform-independent functionality. The platform-independentfunctionality of hybrid application 401 may be executed on client 410relying on a code from webserver module 430 implemented by web browser403 and local files 404. For instance, hybrid application 401 mayinclude commands related to a user interface. Client 410 may display theuser interface-related functionality of hybrid application 401 usingcommands from hybrid application 401 as handled by webserver module 430and implemented by web browser 403. In order for client 410 to executethe platform-specific functionality of hybrid application 401, nativeengine 406, taking advantage of its loose coupling with client 410, maybe configured to receive commands related to the platform-specificfunctionality of client 410, handle the commands at the handler module445, and transmit code corresponding to the platform-specificfunctionality to be executed by client 410.

In one example, client 410 may comprise a handheld scanning device usedin a warehouse environment, and native engine 406 may be installed andrunning on a server or other computer. In this example, client 410 maybe connected to a network in the warehouse environment by which it mayaccess native engine 406. Thus, native engine 406 may be located locallywithin the warehouse environment or outside of the warehouseenvironment, such as on an intranet or on a larger IP network, amongother things. Hybrid application 401 may comprise an applicationconfigured to facilitate the tracking of product or other aspects of thewarehouse environment. Thus, according to the present disclosure,updates may be automatically pushed to hybrid application 401 withoutspecifically updating each client 410. Additionally, client 410 may bereplaced with a new client 410 of an entirely different platform, buthybrid application 401, native engine 406, webserver module 430, andhandler module 445 may still support the new platform. As implemented inthe warehouse environment, client 410 may comprise an IR scanning moduleconfigured to scan barcodes. In this example, client 410 may display auser interface using platform-independent functionality. For instance,web browser 403 may be configured to display code related to the userinterface as received from webserver module 430. However, the userinterface of hybrid application 401 may include a button that the usermay activate when needing to scan a barcode using the IR scanning moduleof client 410, which may comprise platform-specific functionality inthis example. In such cases, native engine 406 and handler module 445may provide native code corresponding to the desired platform-specificfunctionality.

In another example, client 410 may comprise thin client terminalslocated, for instance, on a university campus connected to a universitynetwork. In this example, client 410 may comprise a web browser 403, ahybrid application 410, and local files 404. Client 410 may comprise alight-weight and inexpensive device supporting any number of platforms.Such light-weight devices may offer a number of advantages overtraditional full-powered client devices. Native engine 406 may belocated on a server or other machine on the university network. In oneexample, hybrid application 401 may comprise an application to giveuniversity students access to their university email, class schedule,and other student-specific resources. Hybrid application 401 may includeHTML5 and JavaScript programming to present students with access to theuniversity services. For example, hybrid application 401 may firstpresent the user with a logon screen prompting entry of usercredentials. Client 410 may communicate with native engine 406 and/orwebserver module 430 in order to facilitate the implementation ofcommands related to the logon screen. Hybrid application 401 may alsoinclude platform-specific functionality, such a biometric or image-basedidentification at logon. As described above, commands related toplatform-specific functionality may be transmitted to native engine 406and/or handler module 445, and code corresponding to the givenplatform-specific functionality may be received in return to be executedon client 410.

Of course, the preceding examples are provided for illustrative purposesand are not intended to be an exhaustive list of functionality. Indeed,a wide range of possible uses and implementations are contemplated bythe present disclosure.

FIG. 5 illustrates one embodiment of native engine 506. In thisimplementation, native engine 506 comprises a command dispatch system540 configured to facilitate the transfer of communication data between,to, and from a webserver module 530, a raw socket server 535 and/or aplurality of handlers 545 a-d. The handlers 545 a-d shown in FIG. 5include a database command handler 545 a configured to handle and/orserve commands related to a database, an OS command handler 545 bconfigured to handle and/or serve commands related to functionality of agiven operating system, a peripheral command handler 545 c configured tohandle and/or serve commands related to the peripherals of a clientdevice (for instance, GPS, IR reader, camera, etc.), and a user-definedhandler 545 d configured to handle and/or serve commands related to anyuser-defined functionality.

As used in the present disclosure, platform-specific functionality maycomprise functionality related to any combination, or in the totality,of handlers 545 a-545 d, depending on the platform. For instance, afirst platform may require access to platform-specific code in order toaccess database functionality via database command handler 545 a, whilea second platform may not. In one embodiment, the database with whichdatabase command handler 545 a interacts may reside on a client, such asclient 310 illustrated in FIG. 3. For example, data may be transmittedto the database and stored therein in order to facilitate the operationof an offline mode of a client, such as client 310, where contact withthe remote server, such as remote server 120 in FIG. 1, may not berequired. In another example, the database may reside external to client310.

Command dispatch system 540 may comprise any combination of hardwareand/or software required to facilitate the communication of data within,or external to, native engine 506. For instance, in one example, commanddispatch system 540 may operate in the software stack of client 310.Likewise, webserver module 530 may comprise any suitable type ofwebserver configured to function within the system 100 forplatform-independent application development of the present disclosure.As used herein, a webserver, such as webserver module 530, may be anycombination of hardware and software configured to listen on a networkport, and implement the HTTP server protocol. For example, webservermodule 530 may comprise a standard HTTP server configured to handlecommunications and commands as would any traditional HTTP server.Alternatively, webserver module 530 may comprise a specialized and/orproprietary module configured to handle commands from a hybridapplication, such as hybrid application 301 illustrated in FIG. 3,and/or command dispatch system 540. In one embodiment, webserver module530 may be stored on a system external to native engine 506. Raw socketserver 535 may comprise any suitable module for providing interprocesscommunication and/or listening in on raw sockets. For example, rawsocket server 535 may comprise a Berkeley socket server configured toprovide Internet and Unix domain sockets.

In operation, raw socket server 535 may listen in on raw sockets andreceive a communication from a hybrid application, such as hybridapplication 301 illustrated in FIG. 3. The communication may be passedto command dispatch system 540 in order to determine how thecommunication should be routed. For instance, if the communicationincludes a command for platform-specific functionality, command dispatchsystem 540 may route the command to the appropriate handler 545 a-545 d.If the communication includes a command related to platform-independentfunctionality, command dispatch system 540 may route it to webservermodule 530 for handling.

In one embodiment, a hybrid application, such as hybrid application 301illustrated in FIG. 3, may comprise a music application, as describedabove, comprising application-specific functionality andapplication-independent functionality. Commands from the hybridapplication directed to, for example, user interface layout may bedirected, via command dispatch system 540 to webserver module 530, andthen back to the client for implementation. On the other hand, commandsfrom the hybrid application directed to platform-specific functionality,such as a GPS unit, may be received at command dispatch system 540 anddirected to the appropriate handler 545 a-545 d. In the case of acommand related to the GPS unit, the command may be directed toperipheral command handler 545 c, and an executable code returned to theclient.

In another embodiment, a hybrid application, such as hybrid application401 illustrated in FIG. 4, may comprise an application on a thin client,such as client 410 illustrated in FIG. 4, of a university network. Inthis example, commands from the hybrid application directed toplatform-independent functionality, for example, user interface layoutand function, may be directed, via command dispatch system 540 towebserver module 530, and then back to the client for display. On theother hand, commands from the hybrid application directed toplatform-specific functionality, such as a camera module, may bereceived at command dispatch system 540 and directed to the appropriatehandler 545 a-545 d. In the case of a command related to the cameramodule of the client, the command may be directed to peripheral commandhandler 545 c. In the case of, for example, access to a given bus of theclient, the command may be directed to OS command handler 545 b. Ofcourse, these are but two illustrative examples of how native engine 506may receive, transmit, handle, and serve commands from a hybridapplication, such as hybrid application 301 illustrated in FIG. 3 orhybrid application 401 illustrated in FIG. 4.

FIG. 6 illustrates an embodiment of a remote server 620. Remote server620 may be connected to a client 610 via the Internet 615. As shown inFIG. 6, remote server 620 may comprise a database module 625 comprisingwebserver components 650 and default components 655. The remote server620 further comprises a synchronization server 660, a license server665, and an auto update server 670. The components of remote server 620may be located on the same server or device, or on different servers ordevices, or any suitable combination thereof. Optionally, remote server620 may also comprise a management server 675, as indicated by thebroken lines in FIG. 6. In this example, management server 675 may beconfigured to facilitate communication with a client 610 and properfunction of the system for platform-independent application development,such as the system 100 illustrated in FIG. 1. Management server 675 mayreside in a memory on remote server 620. In this example, the memory maycomprise a non-transitory computer-readable medium comprisinginstructions for executing a method. Alternatively, management server675 may reside on a system or server separate from remote server 620.Management server 675 may work in conjunction with a device managementmodule (not shown) in order to facilitate communication between remoteserver 620 and a client 610. Remote server 620 and its subparts maycomprise any combination of hardware and/or software.

In one embodiment, synchronization server 660 may be available foraccess from a client 610. In one example, a server comprising adatabase, such as database 125 illustrated in FIG. 1, may be locatedexternal to synchronization server 660, and may be located behind afirewall. Meanwhile, management server 675 may reside on the same deviceor server as synchronization server 660, or on a different device orserver. In any case, synchronization server 660 may be configured tocontrol LAN access, synchronization server 660, and/or a database.Additionally, remote server 620 may comprise a system controller (notshown) configured to start, stop, add, and remove servers. In oneexample, the system controller may be configured to be accessible onlyfrom a console of remote server 620.

Default components 655 represent any components that may be installed onremote server 620 by default. For instance, default components 655 mayinclude a database server, a synchronization server, a managementconsole/server, a system services controller, and extended enterpriseconnections (not shown), among other things. In one example, defaultcomponents 655 may comprise a different combination of components andmodules than in another embodiment, based, in part, on the unique needsand interests of a given user. In another example, different defaultcomponents 655 may be offered based on a subscription or license levelof a user. Indeed, a flexible system is contemplated whereby a user maybe provided basic core components in a module of default components 655,and additional components may be added as necessary. For instance, inone embodiment, default components 655 may comprise a combination ofcomponents necessary for managing an application independent developmentenvironment, components necessary to connect to an enterprise database(ODBC connections), third party systems (e.g., third party accounting,CRM, and ERP systems, among other things), and components necessary toconnect to client devices and facilitate the implementation of hybridapplications using a combination of web programming languages, such asHTML5 and JavaScript, and native languages, among other things.

In some embodiments, synchronization server 660 and auto update server670 may be combined into one module. Alternatively, synchronizationserver 660 and auto update server 670 may be independent.Synchronization server 660 and auto update server 670 may be included indefault components 655, or may be installed separately. Synchronizationserver 660 may be configured to facilitate the synchronization of aclient 610, with remote server 620. Auto update server 670 may beconfigured to facilitate pushing updates of a native engine 606, and/orupdates of a hybrid application 601, to a client 610. License server 665may be configured to verify the license of a given user. In oneembodiment, license server 665 may verify whether the developer of ahybrid application 601 has a valid license, and therefore, whetherhybrid application 601 may access remote server 620 and/or native engine606. In another embodiment, license server 665 may verify whether theuser of a hybrid application 601 has a valid license, and therefore,whether the hybrid application 601 may access remote server 620 and/ornative engine 606.

In operation, a hybrid application 601 and/or a native engine 606 mayperiodically connect to remote server 620. For instance, in one example,native engine 606 may attempt to connect to remote server 620 every timenative engine 606 is initialized. Information from database 625 may betransmitted to client 610. For example, synchronization server 660and/or auto update server 670 may communicate with native engine 606 ofa client 610 to verify that all components of native engine 606 and/orhybrid application 601 are synchronized and otherwise up-to-date. Thisverification may comprise sending and/or receiving synchronization datathat may comprise data regarding the current status of a hybridapplication 601 and/or a native engine 606. The synchronization data mayalso comprise data regarding new and unsynchronized data for the hybridapplication 601 and/or the native engine 606. For instance, if theplatform of client 610 were to install an update requiring an update ofnative engine 606, upon connection of native engine 606 with remoteserver 620, files may be accessed and transferred from webservercomponents 650 and/or default components 655 in order to update nativeengine 606 to take advantage of any changes and/or new functionality ofthe platform of client 610. Also, if a developer were to issue an updateof hybrid application 601, upon connection to remote server 620, the newversion of hybrid application 601 could be pushed to client 610.

FIG. 7 illustrates a method 700 comprising a plurality of steps for theoperation of a hybrid application 301 and a native engine 306. In afirst method step 701, native engine 306 is initialized. In oneembodiment, this initialization of native engine 306 may occurautomatically when a client 310 starts up. In another example,initialization of native engine 306 may occur automatically when ahybrid application 301 is initialized. In yet another example, nativeengine 306 may initialize upon receiving a request or interaction from auser, for example, if a user clicks or selects an icon, among otherthings.

In a second step 702, a webserver module 330 is initialized after nativeengine 306 is initialized or concurrently therewith. In some cases, asoftware or hardware error may not allow webserver module 330 toinitialize and a method step 701 b comprising testing whether thewebserver module 330 successfully initialized may throw an error andnotify the user and/or the developer of the native engine 306 of theerror in a method step 701 c. As webserver module 330 initializes, aunique instance ID is created and assigned to the webserver module 330in a third method step 703. The unique instance ID may comprise anysuitable identification configured to identify a given instance ofwebserver module 330. The unique instance ID may be used whentransmitting commands to webserver module 330 and may assist in theavoidance of unauthorized communications and functionality. In a nextmethod step 704, the unique instance ID of native engine 306 ispublished. In one example, the unique instance ID may be communicatedlocally to all hybrid applications 301 installed on a client 310. Inanother example, the unique instance ID may be communicated to a remoteserver, such as remote server 420 illustrated in FIG. 4, or other deviceto facilitate the communication with a native engine, such as nativeengine 406 illustrated in FIG. 4, residing remotely from a hybridapplication 401. Alternatively, the unique instance ID may becommunicated only to clients 410 on a local network shared by a client410 and a native engine 406. Of course, any other suitable arrangementsare also contemplated by the present disclosure.

In a next method step 705, the webserver module 330 is ready to receiveand transmit communications. In one embodiment, webserver module 330indicates this readiness by sending a communication to native engine306. In another embodiment, webserver module communicates directly withany and all hybrid applications 301 installed on a client 310. Inanother example, webserver module 330 does not actively indicatereadiness, and only responds to queries when ready.

A hybrid application 301 may be initialized in parallel with, orindependently of, native engine 306 in a method step 706. In oneembodiment, a hybrid application 301 may be displayed like any nativeapplication, such as, for example, as an icon on a client 310. Inanother embodiment, hybrid application 301 may be accessed through menuavailable through native engine 306 or an application associated withnative engine 306. In a next method step 707, hybrid application 301checks to verify that a webserver module 330 is available on nativeengine 306. If not available, an error may be thrown in another methodstep 708. Assuming that the webserver module 330 is available, a commandfrom hybrid application 301 is appended with the unique instance ID ofwebserver module 330 in a next method step 709. The command withappended unique instance ID is then transmitted to native engine 306and/or webserver module 330 in a next method step 710.

In a next step 711, the command with appended unique instance ID isreceived. In a method step 712, the command may be tested to determinewhether a unique instance ID has been appended. If there is no uniqueinstance ID, then the command is rejected in method step 713. Thus, inone embodiment native engine 306 and webserver module 330 may beconfigured to reject unauthorized communications and access. In anassociated step 714, the appended unique instance ID may be checkedagainst the unique instance ID published in step 704. If there is nomatch, then the communication is rejected and the process is stopped ina method step 715. However, if the unique instance IDs match, then theprocessing of the command may be continued in a next step 716.

However, in a thin client embodiment, native engine 406 and webservermodule 430 may be configured to receive communications and/or commandsexternal sources like client 410. For instance, method step 704comprising publishing the unique instance ID of webserver module 430 maycomprise transmitting unique instance ID to client 410, or to a remoteserver 420. In this example, client 410 may transmit and receivecommunications from native engine 406.

It is to be understood that the preceding method 700 is presented toillustrate operation of a hybrid application 301 and native engine 306,or hybrid application 401 and native engine 406, in one embodiment ofthe present disclosure. One of ordinary skill in the art wouldappreciate that the principles discussed in this disclosure supportadditional methods and processes.

FIG. 8 illustrates a method 800 of operating a native engine 306 that isconsistent with the present disclosure. In an initial step 801, a nativeengine, such as native engine 306 illustrated in FIG. 3, is initializedis initialized on a client. Native engine 306 may automaticallyinitialize upon startup of a client, such as client 310 illustrated inFIG. 3, or it may initialize as the result of a user selection orinteraction, such as a click. In a next step 802, a detection routinemay run to determine whether the application has ever initializedpreviously, or if the present initialization represents the first timethat the application has initialized.

If it is determined that this initialization represents the firstinitialization of the native engine 306, then a subroutine may run totest the presence of a connection to the Internet and to syncapplication data in steps 803 and 805. In Internet detection step 803,the native engine 306 may attempt to connect to remote server 320, inorder perform any initial setup that may be required. For instance, itmay be required to sync application data to client 310. It may also benecessary to verify a license prior to providing access to content,among other things. If the native engine 306 is unable to establish aconnection to remote server 320, or otherwise unable to detect aconnection to the Internet, then in a step 804 the native engine 306 mayprovide a notification to the user via, for example, a prompt on thescreen of client 310. In one example, the notification may indicate thelack of Internet connectivity and inform the user that he or she willneed to connect to the Internet to continue using the native engine 306and/or any associated applications. In a different embodiment, thenotification may inform the user of the lack of connectivity, butnevertheless provide limited access to its functionality. The step 805of syncing application data may comprise providing remote server 320with information about the particular installation of an applicationand/or native engine 306, and may receive information from remoteserver. For instance, remote server 320 may transmit updated files tonative engine 306.

In a next method step 806, the native engine 306 will detect whethermultiple hybrid applications 301 are installed or otherwise associatedwith client 310. If more than one hybrid application 301 is installed,then the native engine 306 will run a subroutine comprising displayingan application list in a method step 807, and detecting a user selectionin a method step 808. In a next method step 809, a page associated witha hybrid application 301 will be received by client 310 and/or nativeengine 306. For example, hybrid application 301 may have an initialscreen that may be displayed using a web programming language such asHTML5 and/or JavaScript. In this example, hybrid application 301 maytransmit commands related to its initial screen to native engine 306 forimplementation in this step. The commands received from hybridapplication 301 may comprise a combination of HTML5 and JavaScriptcommands, and native engine 306 may implement and/or display the HTML5commands normally while detecting and sending the JavaScript commandsthrough a webserver module 330 for processing and implementation in astep 810. This processing may comprise sending parameters to webservermodule 330 in a method step 811. In one example, the commands receivedfrom hybrid application 301 may comprise commands requesting access to adatabase programmed in JavaScript, and the command parameters may besent on to webserver module 330 for processing.

Associated with step 811, the webserver 330 can parse the command tofind the relevant request command. In a next step 812, it is determinedwhether a command handler is available for the request. If noappropriate handler is found, then an error is thrown in a step 813, andthe process terminates. Otherwise, in a step 814, the appropriatehandler is created and the parameters are passed to the handler. Forexample, the command may require an OS command handler 545 b, aperipheral command handler 545 c, or a user-defined command handler 545d, among other things. For instance, the command may be related to theoperation of a GPS of a client 310, and the relevant peripheral commandhandler, such as peripheral command handler 545 c, may receive thecommand and parse out the appropriate command language, among otherthings.

In method step 815, the handler will handle the command. In some cases,this may represent a result being returned. In other cases, it willresult in executable code, among other things, being returned, which maytrigger a success event in response to the JavaScript call. In oneexample, database command handler 545 a may return data from a database,or may return a success result. In another example, OS command handler545 b may return executable code related to a platform-specificfunctionality, such as, for example, an LED on a client 310. In yetanother example, peripheral command handler 545 c may return a resultrelated to a peripheral function. For instance, peripheral commandhandler 545 c may return a result, such as executable code or otherdata, related to a peripheral of client 310. The returned result maycomprise, for example, a geospatial position of client 310, or it maycomprise executable code from an IR reader or a Bluetooth module, amongother things. Additionally, user-defined handler 545 d may return aresult related to a user-defined function. For instance, a developer maydevelop a handler for performing a predetermined function, and may setup a specific handler to perform the predetermined function.

In a next method step 817, a browser or the platform may execute theresult returned. For example, if the command sent was related toverifying a username and a password, the result could relate to thesuccess of the username/password combination, or that there was an erroror mismatch. In another example, if the command was related to accessinga platform-specific functionality, the result could be executable coderelated to the platform-specific functionality.

In one example of method step 817, the result is executed or processed.For instance, if the relevant handler 545 a-545 d returns executablecode, then the code will be executed on client 310. In one example,database command handler 545 a may return code related to content on ina database 125. For instance, database command handler 545 a may returninformation related to the user of client 310, such as a name and/orprofile information, among other things, to provide a dynamicexperience. In another example, code may be returned related to aplatform-specific functionality.

The present disclosure illustrates the advantages of a system having aloosely-coupled native engine comprise a webserver module. Aloosely-coupled native engine may be configured to facilitate theimplementation of hybrid applications on a wide range of clients,including mobile devices and thin clients, among other things. Aloosely-coupled native engine comprising a webserver module may beconfigured to facilitate the interpretation of commands related to bothplatform-specific functionality and platform-independent functionalitywithout transmitting the commands a remote server.

Although this disclosure has been described in terms of certainpreferred embodiments, other embodiments that are apparent to those ofordinary skill in the art, including embodiments that do not provide allof the features and advantages set forth herein, are also within thescope of this disclosure. Accordingly, the scope of the presentdisclosure is defined only by reference to the appended claims andequivalents thereof.

What is claimed is:
 1. A device compatible with a first platform, the device comprising: a memory configured to store local files; a loosely-coupled native engine comprising: a webserver module; a command dispatch system connected to the webserver module and configured to pass commands to, and receive commands from, the webserver module; and a plurality of handlers configured to handle commands from the command dispatch system and serve a resulting code; wherein the webserver module of the native engine receives a unique instance identifier (ID) upon initialization of an instance of the webserver module, and the unique instance ID is transmitted to the memory; further wherein the webserver module is configured to reject communications that do not include the unique instance ID; and a hybrid application programmed in a platform-independent development environment, wherein the hybrid application comprises commands to be transmitted to the webserver module of the loosely-coupled native engine, and wherein the commands comprise the unique instance ID of the webserver module.
 2. The device of claim 1 further comprising a raw socket server communicably connected to the command dispatch system.
 3. The device of claim 1 wherein the loosely-coupled native engine is configured to transmit and receive communications from a remote server comprising a synchronization server, and wherein the received communications comprise synchronization data.
 4. The device of claim 1 wherein the loosely-coupled native engine is configured to transmit and receive communications from a remote server comprising a license server, and wherein the license server is configured to verify that a license associated with the loosely-coupled native engine is valid.
 5. The device of claim 1 wherein the loosely-coupled native engine is configured to transmit and receive communications from a remote server comprising an auto update server, and wherein the auto update server is configured transmit updates of the loosely-coupled native engine or the hybrid application to the device.
 6. The device of claim 1 wherein the resulting code from the plurality of handlers is executed by the device.
 7. The device of claim 1 wherein the loosely-coupled native engine is configured to parse commands from the hybrid application, detect commands comprising JavaScript, and send the commands comprising JavaScript to the webserver module.
 8. A non-transitory computer-readable medium having instructions that when executed cause the implementation of a method, the medium having instructions for facilitating the execution of at least a first hybrid application on a first device, the first hybrid application comprising commands related to platform-specific functionality and platform-independent functionality of the first device, the method comprising: initializing a loosely-coupled native engine configured to receive commands from the first hybrid application and to facilitate platform-specific functionality on the first device; wherein the loosely-coupled native engine comprises a webserver module; receiving commands from the first hybrid application, wherein at least one of the commands comprises a device command to be converted to a corresponding platform-specific code prior to execution of the platform-specific code; and creating a handler to serve the device command and facilitate execution of the corresponding platform-specific code.
 9. The computer-readable medium of claim 8 further comprising: transmitting commands from the first hybrid application to the native engine, wherein the first device comprises a thin client device which comprises the first hybrid application, and a remote device is communicably connected to the thin client device, the remote device comprising the loosely-coupled native engine; transmitting the corresponding platform-specific code from the native engine to the thin client device; and executing the corresponding platform-specific code on the thin client device.
 10. The computer-readable medium of claim 9 further comprising: receiving commands from a second hybrid application of a second device of a second platform, wherein the first device is of a first platform; converting the commands from the second hybrid application into a corresponding platform-specific code related to the second platform; and transmitting the corresponding platform-specific code related to the second platform to the second device for execution.
 11. The computer-readable medium of claim 8 wherein: initializing the loosely-coupled native engine comprises receiving an instance ID corresponding to an instance of the webserver module; receiving commands of the first hybrid application comprises verifying that the commands comprise the instance ID of the webserver module; and rejecting commands that do not comprise the instance ID of the webserver module.
 12. The computer readable medium of claim 8 wherein the created handler comprises a peripheral handler.
 13. A method of executing platform-independent applications comprising: initializing a hypertext transfer protocol (HTTP) server at a device; assigning a unique instance identifier (ID) to the HTTP server; receiving commands corresponding to a hybrid application, the commands including the unique instance ID, and at least one of the commands including a device command to be converted to corresponding platform-specific executable code prior to execution of the platform-specific executable code; verifying that the commands include the unique instance ID; and initializing a handler to serve the device command including initiating execution of the corresponding platform-specific executable code.
 14. The method of claim 13, wherein the hybrid application includes commands related to platform-specific functionality and platform-independent functionality of the device.
 15. The method of claim 13, further comprising converting the commands to the corresponding platform-specific executable code using a lookup table.
 16. The method of claim 13, further comprising converting the commands to the corresponding platform-specific executable code by retrieving conversion information from a database.
 17. The method of claim 13, further comprising transmitting the unique instance ID to a client.
 18. The method of claim 13, wherein the commands are received from a client via a raw socket server.
 19. The method of claim 13, further comprising using a web browser to interpret and execute a subset of the commands that may be executed without platform-specific functionality.
 20. The method of claim 13, further comprising: receiving the hybrid application at a remote server; and pushing the hybrid application to an application distribution center for distribution to a plurality of clients. 